{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.io import loadmat\n",
    "from sklearn.preprocessing import PolynomialFeatures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "\n",
    "matplotlib.rcParams['font.sans-serif'] = ['SimHei']\n",
    "matplotlib.rcParams['axes.unicode_minus'] = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def h(theta, x):\n",
    "    '''\n",
    "    预测函数\n",
    "    Args:\n",
    "        theta 模型参数\n",
    "        X 特征向量\n",
    "    Return:\n",
    "        预测结果\n",
    "    '''\n",
    "    return np.dot(x, theta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def J(theta, X, y, theLambda=0):\n",
    "    '''\n",
    "    代价函数\n",
    "    Args:\n",
    "        theta 模型参数\n",
    "        X 样本特征\n",
    "        y 样本标签\n",
    "    Return:\n",
    "        预测误差\n",
    "    '''\n",
    "    m, n = X.shape\n",
    "    return (h(theta, X) - y).T * (h(theta,X) -y) / (2 * m) + theLambda * np.sum(np.square(theta)) / (2*m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient(X, y, alpha, maxLoop=50, epsilon=1e-5, theLambda=0, initTheta=None):\n",
    "    '''\n",
    "    批量梯度下降\n",
    "    Args:\n",
    "        X 样本特征\n",
    "        y 样本标签\n",
    "        alpha 学习率\n",
    "        maxLoop 最大迭代次数\n",
    "        epsilon 收敛精度\n",
    "        theLambda 正则化参数\n",
    "        initTheta 初始化参数\n",
    "    Returns:\n",
    "        theta, errors\n",
    "    '''\n",
    "    m, n = X.shape\n",
    "    converged = False\n",
    "    # 初始化theta\n",
    "    if initTheta is None:\n",
    "        theta = np.zeros((n,1))\n",
    "    else:\n",
    "        theta = initTheta\n",
    "    count = 0\n",
    "    \n",
    "    error = np.inf\n",
    "    errors = [error]\n",
    "    while count <= maxLoop:\n",
    "        if converged :\n",
    "            break\n",
    "        count += 1\n",
    "        theta = theta + (1.0 / m) * alpha * ((y - X * theta).T * X).T\n",
    "        error = J(theta, X, y, theLambda)\n",
    "        if np.isnan(error):\n",
    "            error = np.inf\n",
    "        errors.append(error)\n",
    "        # 如果已经收敛\n",
    "        if abs(errors[-1]-errors[-2]) < epsilon:\n",
    "            break\n",
    "    return theta, errors\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize(X):\n",
    "    '''\n",
    "    特征归一化处理\n",
    "    Args:\n",
    "        X 样本集\n",
    "    Returns:\n",
    "        归一化后的样本集    \n",
    "    '''\n",
    "    m, n = X.shape\n",
    "    for j in range(n):\n",
    "        features = X[:,j]\n",
    "        minVal = features.min(axis=0)\n",
    "        maxVal = features.max(axis=0)\n",
    "        diff = maxVal-minVal\n",
    "        if diff != 0:\n",
    "            X[:,j] = (features - minVal)/diff\n",
    "        else:\n",
    "            X[:,j] = 0\n",
    "    return X\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = loadmat('data/water.mat')\n",
    "X = np.mat(data['X'])\n",
    "# 训练集\n",
    "X = np.concatenate((np.ones((X.shape[0],1)), X),axis = 1)\n",
    "y = np.mat(data['y'])\n",
    "# 交叉验证集\n",
    "Xval = np.mat(data['Xval'])\n",
    "Xval = np.concatenate((np.ones((Xval.shape[0], 1)), Xval), axis=1)\n",
    "yval = np.mat(data['yval'])\n",
    "# 测试集\n",
    "Xtest = np.mat(data['Xtest'])\n",
    "Xtest = np.concatenate((np.ones((Xtest.shape[0], 1)), Xtest), axis=1)\n",
    "ytest = np.mat(data['ytest'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diagnoseLR():\n",
    "    \"\"\"线性回归诊断\n",
    "    \"\"\"\n",
    "    initTheta = np.mat(np.ones((X.shape[1], 1)))\n",
    "    theta, errors = gradient(\n",
    "        X, y, alpha=0.001, maxLoop=5000, epsilon=0.00001, initTheta=initTheta)\n",
    "\n",
    "    # 绘制拟合成果\n",
    "    Xmin = X[:, 1].min()\n",
    "    Xmax = X[:, 1].max()\n",
    "    ymax = y[:, 0].max()\n",
    "    ymin = y[:, 0].min()\n",
    "    fitX = np.mat(np.linspace(Xmin, Xmax, 20).reshape(-1, 1))\n",
    "    fitX = np.concatenate((np.ones((fitX.shape[0], 1)), fitX), axis=1)\n",
    "\n",
    "    h = fitX * theta\n",
    "    plt.xlim(Xmin, Xmax)\n",
    "    plt.ylim(ymin, ymax)\n",
    "    # 绘制训练样本\n",
    "    plt.scatter(X[:, 1].tolist(), y[:, 0].tolist(),marker='x',color='r', linewidth=2)\n",
    "    # 绘制拟合曲线\n",
    "    plt.plot(fitX[:, 1], h, color='b')\n",
    "    plt.xlabel(u'水位变化(x)')\n",
    "    plt.ylabel(u'大坝流量(y)')\n",
    "    plt.show()\n",
    "\n",
    "    # 绘制随样本规模学习曲线\n",
    "    m, n = X.shape\n",
    "    trainErrors = np.zeros((1,m))\n",
    "    valErrors = np.zeros((1,m))\n",
    "    for i in range(m):\n",
    "        Xtrain = X[0:i+1]\n",
    "        ytrain = y[0:i+1]\n",
    "        # 注意，这里我们没有设置theLambda，实际上没有必要\n",
    "        theta, errors = gradient(\n",
    "            Xtrain, ytrain, alpha=0.001, maxLoop=10000, epsilon=0.00001)\n",
    "        \n",
    "        trainErrors[0,i] = J(theta, Xtrain, ytrain)\n",
    "        valErrors[0,i] = J(theta, Xval, yval)\n",
    "\n",
    "    print(u'最小交叉验证误差', valErrors.ravel()[-1])\n",
    "    plt.plot(np.arange(1,m+1).ravel(), trainErrors.ravel(), color='b', label=u'训练误差')\n",
    "    plt.plot(np.arange(1,m+1).ravel(), valErrors.ravel(), color='g', label=u'交叉验证误差')\n",
    "    plt.title(u'线性回归学习曲线')\n",
    "    plt.xlabel(u'训练样本量')\n",
    "    plt.ylabel(u'误差')\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.ravel?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x17ac170d278>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最小交叉验证误差 29.564752654802668\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x17ac18bff60>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "diagnoseLR()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diagnosePR():\n",
    "    \"\"\"多项式回归诊断\n",
    "    \"\"\"\n",
    "    # 多项式回归\n",
    "    poly = PolynomialFeatures(degree=10)\n",
    "    XX, XXval, XXtest = [normalize(\n",
    "        np.mat(poly.fit_transform(data[:, 1:]))) for data in [X, Xval, Xtest]]\n",
    "    initTheta = np.mat(np.ones((XX.shape[1], 1)))\n",
    "    theLambdas = [0, 0.01, 0.02, 0.03, 0.04, 0.05,0.06,0.07, 0.08, 0.09,0.10, 0.11, 0.12,0.13,0.14,0.15,0.2,0.3,0.5]\n",
    "    numTheLambdas = len(theLambdas)\n",
    "    trainErrors = np.zeros((1, numTheLambdas))\n",
    "    valErrors = np.zeros((1, numTheLambdas))\n",
    "    thetas = []\n",
    "    for idx, theLambda in enumerate(theLambdas):\n",
    "        theta, errors = gradient(\n",
    "            XX, y, alpha=0.1, maxLoop=10000, epsilon=0.0001,\n",
    "            theLambda=theLambda, initTheta=initTheta)\n",
    "        \n",
    "        thetas.append(theta)\n",
    "        # 训练误差、交叉验证误差，不需要考虑模型复杂度，所以theLambda不需要设置或者设置成0\n",
    "        trainErrors[0, idx] = J(theta,XX,y)\n",
    "        valErrors[0, idx] = J(theta, XXval, yval)\n",
    "        print(theLambda, valErrors[0,idx])\n",
    "\n",
    "    bestLambda = theLambdas[np.argmin(valErrors)]\n",
    "    theta = thetas[np.argmin(valErrors)]\n",
    "    error = np.min(valErrors)\n",
    "    print('the best one:',bestLambda, error)\n",
    "\n",
    "    # # 选择lambda\n",
    "    plt.plot(theLambdas, trainErrors.ravel(), color='b',label=u'训练误差')\n",
    "    plt.plot(theLambdas, valErrors.ravel(), color='g',label=u'交叉验证误差')\n",
    "    plt.title(u'多项式回归选择λ')\n",
    "    plt.xlabel(u'λ')\n",
    "    plt.ylabel(u'误差')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "    # 绘制拟合曲线\n",
    "    fitX = np.mat(np.linspace(-60, 45).reshape(-1, 1))\n",
    "    fitX = np.concatenate((np.ones((fitX.shape[0], 1)), fitX), axis=1)\n",
    "    fitXX = normalize(np.mat(poly.fit_transform(fitX[:, 1:])))\n",
    "    h = fitXX * theta\n",
    "    print(theta)\n",
    "    plt.title(u'多项式回归拟合曲线(lambda=%.3f) \\n  交叉验证误差=%.3f' % (bestLambda, error))\n",
    "    \n",
    "    plt.scatter(X[:, 1].tolist(), y[:, 0].tolist(), marker='x', color='r', linewidth=3)\n",
    "    plt.plot(fitX[:, 1], h, color='b')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 15.243389466469202\n",
      "0.01 15.012599523662516\n",
      "0.02 14.76196366423922\n",
      "0.03 14.529461480173763\n",
      "0.04 14.33384327902734\n",
      "0.05 14.1872899757646\n",
      "0.06 14.093184875253355\n",
      "0.07 14.053284486207568\n",
      "0.08 14.061918063936224\n",
      "0.09 14.112333334428364\n",
      "0.1 14.198147212683498\n",
      "0.11 14.311753596608908\n",
      "0.12 14.445531704002516\n",
      "0.13 14.600809651263196\n",
      "0.14 14.76189813136848\n",
      "0.15 14.936084971453134\n",
      "0.2 15.934299059503648\n",
      "0.3 16.471327701795325\n",
      "0.5 22.224487377564373\n",
      "the best one: 0.07 14.053284486207568\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x17ac1c80c88>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1.        ]\n",
      " [ 33.95102063]\n",
      " [ 18.6465778 ]\n",
      " [ 12.39603696]\n",
      " [  6.03626333]\n",
      " [ -0.35284465]\n",
      " [ -2.41587214]\n",
      " [ -8.76756631]\n",
      " [ -7.44441674]\n",
      " [-14.36476901]\n",
      " [-10.39025965]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x17ac1ee4c18>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "diagnosePR()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
